import { createFlatRequest } from '@sa/axios';
import { request } from '../request';

// 创建专门的 RabbitMQ 测试请求实例，指向同源服务
// 功能：用于在需要独立请求实例时，基于同源路径创建请求客户端，避免混合内容问题
const rabbitmqTestRequest = createFlatRequest<App.Service.Response>({
  baseURL: '/',
  headers: {
    'Content-Type': 'application/json'
  }
});

/** MQ消息记录 */
export interface MqMessageRecord {
  messageId: string;
  type: 'SEND' | 'RECEIVE';
  queueName: string;
  content: string;
  properties: string;
  createTime: string;
  status: 'SUCCESS' | 'FAILED';
  errorMessage: string | null;
  nodeInfo: string | null;
  url: string | null;
}

/** 发送消息请求参数 */
export interface SendMessageRequest {
  queueName: string;
  content: string;
  properties?: Record<string, any>;
}

/** MQ消息发送请求参数（对应后端MQController） */
export interface MqMessageRequest {
  message: string;
  properties?: Record<string, any>;
}

/** 租户队列状态 */
export interface TenantQueueStatus {
  tenantId: string;
  isListening: boolean;
}

/** 获取消息记录列表 */
export function getMqMessageRecords(limit = 100) {
  // 功能：获取 MQ 消息列表，统一使用同源 request 实例，避免跨域混合内容
  return request<MqMessageRecord[]>({
    url: '/api/mq-messages',
    method: 'get',
    params: { limit }
  });
}

/** 获取指定消息记录 */
export function getMqMessageRecord(messageId: string) {
  // 功能：根据消息ID获取 MQ 消息详情
  return request<MqMessageRecord>({
    url: `/api/mq-messages/${messageId}`,
    method: 'get'
  });
}

/** 发送消息到指定队列（使用MqMessageRecordController） */
export function sendMqMessage(data: SendMessageRequest) {
  // 功能：发送 MQ 消息到队列
  return request<string>({
    url: '/api/mq-messages/send',
    method: 'post',
    data
  });
}

/** 获取可用的队列列表 */
export function getAvailableQueues() {
  // 功能：获取当前可用的 MQ 队列
  return request<string[]>({
    url: '/api/mq-messages/queues',
    method: 'get'
  });
}

// ========== MQController 接口 ==========

/**
 * 发送带属性的异步请求消息 功能：调用后端 MQController 的异步消息接口
 *
 * @param tenantId 租户ID
 * @param data 消息数据
 */
export function sendAsyncMessage(tenantId: string, data: MqMessageRequest) {
  return request<string>({
    url: `/mq/async-req/${tenantId}/with-properties`,
    method: 'post',
    data
  });
}

/**
 * 发送带属性的同步消息并等待响应 功能：调用后端 MQController 的同步消息接口
 *
 * @param tenantId 租户ID
 * @param data 消息数据
 * @param timeout 超时时间(毫秒)
 */
export function sendSyncMessage(tenantId: string, data: MqMessageRequest, timeout = 5000) {
  return request<any>({
    url: `/mq/sync/${tenantId}/with-properties`,
    method: 'post',
    data,
    params: { timeout }
  });
}

/**
 * 发送带属性的异步回复消息 功能：调用后端 MQController 的异步回复接口
 *
 * @param tenantId 租户ID
 * @param data 消息数据
 */
export function sendAsyncReply(tenantId: string, data: MqMessageRequest) {
  return request<string>({
    url: `/mq/async-reply/${tenantId}/with-properties`,
    method: 'post',
    data
  });
}

/**
 * 获取租户队列状态 功能：查询指定租户的队列监听状态
 *
 * @param tenantId 租户ID
 */
export function getTenantQueueStatus(tenantId: string) {
  return request<TenantQueueStatus>({
    url: `/tenant-queue/status/${tenantId}`,
    method: 'get'
  });
}

/**
 * 暂停租户队列监听
 *
 * @param tenantId 租户ID
 */
export function pauseTenantQueue(tenantId: string) {
  return request<string>({
    url: `/tenant-queue/pause/${tenantId}`,
    method: 'post'
  });
}

/**
 * 恢复租户队列监听
 *
 * @param tenantId 租户ID
 */
export function resumeTenantQueue(tenantId: string) {
  return request<string>({
    url: `/tenant-queue/resume/${tenantId}`,
    method: 'post'
  });
}

// ========== RabbitMqTestController 接口 ==========

/** RabbitMQ 测试消息请求参数 */
export interface RabbitMqTestRequest {
  queueName: string;
  content: string;
  properties?: Record<string, any>;
  messageType?: 'TEXT' | 'JSON' | 'XML';
}

/** RabbitMQ 测试消息响应 */
export interface RabbitMqTestResponse {
  success: boolean;
  messageId: string;
  queueName: string;
  timestamp: string;
  response?: any;
  error?: string;
}

/**
 * 发送 RabbitMQ 测试消息
 *
 * @param data 消息数据
 */
export async function sendRabbitMqTestMessage(data: RabbitMqTestRequest): Promise<RabbitMqTestResponse> {
  try {
    const response = await rabbitmqTestRequest({
      url: '/api/rabbit-mq-test/send',
      method: 'post',
      data
    });

    // 如果响应成功，返回数据
    if (response.data) {
      return response.data as RabbitMqTestResponse;
    }

    // 如果没有数据，返回默认成功响应（不包含原始response避免重复包装）
    return {
      success: true,
      messageId: `msg-${Date.now()}`,
      queueName: data.queueName,
      timestamp: new Date().toISOString()
    };
  } catch (error: any) {
    // 返回错误响应
    return {
      success: false,
      messageId: '',
      queueName: data.queueName,
      timestamp: new Date().toISOString(),
      error: error.message || '发送失败'
    };
  }
}

/**
 * 接收 RabbitMQ 测试消息
 *
 * @param queueName 队列名称
 */
export async function receiveRabbitMqTestMessage(queueName: string): Promise<RabbitMqTestResponse> {
  try {
    const response = await rabbitmqTestRequest({
      url: `/api/rabbit-mq-test/receive/${queueName}`,
      method: 'get'
    });

    // 如果响应成功，返回数据
    if (response.data) {
      return response.data as RabbitMqTestResponse;
    }

    // 如果没有数据，返回默认响应
    return {
      success: false,
      messageId: '',
      queueName,
      timestamp: new Date().toISOString(),
      error: '暂无新消息'
    };
  } catch (error: any) {
    // 返回错误响应
    return {
      success: false,
      messageId: '',
      queueName,
      timestamp: new Date().toISOString(),
      error: error.message || '接收失败'
    };
  }
}

/** 获取 RabbitMQ 测试队列列表 */
export async function getRabbitMqTestQueues(): Promise<string[]> {
  try {
    const response = await rabbitmqTestRequest({
      url: '/api/rabbit-mq-test/queues',
      method: 'get'
    });

    // 如果响应成功，返回队列列表
    if (response.data && Array.isArray(response.data)) {
      return response.data;
    }

    // 如果没有数据，返回空数组
    return [];
  } catch (error: any) {
    console.error('获取队列列表失败:', error);
    throw new Error(error.message || '获取队列列表失败');
  }
}
